/*
    * Copyright 2004-2005, University Health Network.  All rights reserved. Distributed under the BSD 
    * license (see http://opensource.org/licenses/bsd-license.php).
    *  
    * Created on 6-Dec-2004
    */
   package ca.uhn.cache.impl;
   
   import java.util.Iterator;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.beans.factory.InitializingBean;
  
  import ca.uhn.cache.IDataItem;
  import ca.uhn.cache.IDataSource;
  import ca.uhn.cache.IQuery;
  import ca.uhn.cache.IQueryResult;
  import ca.uhn.cache.ISemanticCache;
  import ca.uhn.cache.exception.CacheException;
  import ca.uhn.cache.exception.DataSourceException;
  import ca.uhn.cache.util.QueryResultUtil;
  
  /***
   * An <code>IDataSource</code> that is an underlying <code>IDataSource</code>
   * wrapped in a read-through cache.
   * 
   * TODO: We allow a single result to correspond to multiple queries in
   * IDataSource ... this might create a cache consistency problem ... if a query
   * is performed, then we get remainder results, then the cached portion is
   * purged, then we populate the cache with the remainder, then the descriptor of
   * the remainder will include the cached portion which has been purged. We don't
   * get this problem if we only allow one query per result.
   * 
   * @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp </a>
   * @version $Revision: 1.1 $ updated on $Date: 2005/01/24 22:52:33 $ by $Author:
   *          btripp $
   */
  public class SelfCachingDataSource implements IDataSource, InitializingBean {
  
      private static final Log ourLog = LogFactory.getLog( SelfCachingDataSource.class );
      
      private static final IQueryResult EMPTY_QUERY_RESULT = new QueryResult();
  
      private ISemanticCache mySemanticCache;
  
      private IDataSource myDataSource;
  
      private int myMaxQueryGroups = -1;
  
      //private Executor myExecutor;
  
      // /***
      // * @param theCache cache that holds query results and may partially or completely answer queries
      // * @param theSource original source of data to be cached / returned to caller as needed
      // * @param theMaxRemainderQueries maximum number of remainder queries that can be used to obtain 
      // * the non-cached portion of a query result
      // */
      // public SelfCachingDataSource(ISemanticCache theCache, IDataSource
      // theSource, int theMaxRemainderQueries) {
      // myCache = theCache;
      // mySource = theSource;
      // myMaxQueryGroups = theMaxRemainderQueries;
      //        
      // myExecutor = new PooledExecutor(new BoundedBuffer(20), 100);
      // ((PooledExecutor) myExecutor).setMinimumPoolSize(5);
      // }
  
      /***
       * Default constructor.
       */
      public SelfCachingDataSource() {
  //        myExecutor = new PooledExecutor( new BoundedBuffer( 20 ), 100 );
  //        ((PooledExecutor) myExecutor).setMinimumPoolSize( 5 );
      }
  
      /***
       * Note that there is no optimization for sending multiple queries at once
       * (queries are executed in series).
       * 
       * @see ca.uhn.cache.IDataSource#execute(ca.uhn.cache.IQuery[])
       */
      public IQueryResult execute( IQuery[] theQueries ) throws DataSourceException {
          if (theQueries.length == 0) {
              throw new IllegalArgumentException( "The list of queries is empty" );
          }
  
          IQueryResult result = execute( theQueries[0] );
  
          // merge additional queries ...
          for (int i = 1; i < theQueries.length; i++) {
              Iterator nextResults = execute( theQueries[i] ).iterator();
              while (nextResults.hasNext()) {
                  result.add( (IDataItem) nextResults.next() );
              }
          }
  
          return result;
      }
 
     private IQueryResult execute( IQuery theQuery ) throws DataSourceException {
         //TODO enhance the IQueryResult interface to keep track of any exceptions that were thrown during 
         //the execution of the "execute" method.
         
         IQueryResult retVal;
         
         boolean useCachedResult = true;
 
         IQueryResult cachedResult = null;
         try {
             cachedResult = getSemanticCache().get( theQuery );
         }
         catch (CacheException e) {
             useCachedResult = false;
             ourLog.error( "Exception thrown while executing the get method of the cache", e );
         }
         
         IQuery[] remainders = null;
         if ( useCachedResult == true ) {
             try {
                 remainders = getSemanticCache().remainder( theQuery, myMaxQueryGroups );
             }
             catch (CacheException e) {
                 useCachedResult = false;
                 ourLog.error( "Exception thrown while executing the remainder method of the cache", e );
             }
         }
         
         IQueryResult sourceResult = EMPTY_QUERY_RESULT;
         if ( useCachedResult == true ) {
             if ( remainders.length != 0) {
                 sourceResult = getDataSource().execute( remainders );
             }
         }
         else {
             sourceResult = getDataSource().execute( new IQuery[] { theQuery } );
         }
 
         if ( useCachedResult == true && !sourceResult.isEmpty() ) {
             try {
                 //TODO: scope includes cached data ... synchronization problem?
                 for (int i = 0; i < remainders.length; i++) {
                     IQuery remainderQuery = remainders[i];
                     //the key of the cache must be a remainder query
                     getSemanticCache().put( remainderQuery, QueryResultUtil.filter( sourceResult, remainderQuery ) );
                 }
             }
             catch (CacheException e) {
                 ourLog.error( "Exception thrown while executing the put method of the cache", e );
             } 
         }
 
         IQueryResult filteredSourceResult = QueryResultUtil.filter(sourceResult, theQuery);
         
         if ( useCachedResult == true ) {
             retVal = cachedResult.append( filteredSourceResult );    
         }
         else {
             retVal = filteredSourceResult;
         }
             
         return retVal;
     }
 
 //    private void addResults( final IQuery theQuery, final IDataSource theSource, final QueryProcessor theProcessor )
 //            throws DataSourceException {
 //
 //        Runnable r = new Runnable() {
 //
 //            public void run() {
 //                try {
 //                    IQueryResult result = theSource.execute( new IQuery[] { theQuery } );
 //                    theProcessor.setSourceResult( theQuery, result );
 //                }
 //                catch (DataSourceException e) {
 //                    theProcessor.declareException( "Problem querying original source", e );
 //                }
 //            }
 //        };
 //
 //        try {
 //            myExecutor.execute( r );
 //        }
 //        catch (InterruptedException e) {
 //            throw new DataSourceException( e ) {
 //            };
 //        }
 //    }
 
     // Do we want these setters & getters? other code shouldn't care, and we
     // don't want the values to change after instantiation.
 
     // ////////SPRING BEGIN /////////
 
     /***
      * @return Semantic cache that holds query results and may partially or completely answer queries.
      */
     public ISemanticCache getSemanticCache() {
         return mySemanticCache;
     }
 
     /***
      * @param theSemanticCache The semantic cache to set.
      */
     public void setSemanticCache( ISemanticCache theSemanticCache ) {
         mySemanticCache = theSemanticCache;
     }
 
     /***
      * @return The maximum number of queries that will be sent to the underlying data source at a time.
      * 
      * @see ISemanticCache#remainder(IQuery, int)
      */
     public int getMaxQueryGroups() {
         return myMaxQueryGroups;
     }
 
     /***
      * @param theMaxQueryGroups The maxQueryGroups to set.
      */
     public void setMaxQueryGroups( int theMaxQueryGroups ) {
         myMaxQueryGroups = theMaxQueryGroups;
     }
 
     /***
      * The underlying data source.
      * 
      * @return Returns the source.
      */
     public IDataSource getDataSource() {
         return myDataSource;
     }
 
     /***
      * @param theDataSource The source to set.
      */
     public void setDataSource( IDataSource theDataSource ) {
         myDataSource = theDataSource;
     }
 
     /***
      * {@inheritDoc}
      */
     public void afterPropertiesSet() throws Exception {
         assert getDataSource() != null;
         assert getSemanticCache() != null;
         assert getMaxQueryGroups() != -1;
     }
 
     // ////////SPRING END /////////
 
 }